home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / OpenGL 1.0 SDK / Documentation / multitexture.txt < prev    next >
Encoding:
Text File  |  1999-05-18  |  42.3 KB  |  964 lines  |  [TEXT/ttxt]

  1. Name
  2.  
  3.     EXT_multitexture
  4.  
  5. Name Strings
  6.  
  7.     GL_EXT_multitexture
  8.  
  9. Version
  10.  
  11.     $Date: 1998/05/12 23:52:21 $ $Revision: 1.18 $
  12.  
  13. Number
  14.  
  15.     116
  16.  
  17. Dependencies
  18.  
  19.     OpenGL 1.1 is required 
  20.     EXT_texture3D affects the definition of this extension.
  21.     SGIS_texture4D affects the definition of this extension.
  22.     SGIS_texture_border_clamp affects the definition of this extension.
  23.     SGI_texture_color_table affects the definition of this extension.
  24.     SGIS_texture_edge_clamp affects the definition of this extension.
  25.     SGIX_texture_add_env affects the definition of this extension.
  26.     SGIS_texture_filter4 affects the definition of this extension.
  27.     SGIS_texture_lod affects the definition of this extension.
  28.     SGIX_texture_lod_bias affects the definition of this extension.
  29.     SGIX_texture_scale_bias affects the definition of this extension.
  30.     SGIS_texture_select affects the definition of this extension.
  31.     SGIS_detail_texture affects the definition of this extension.
  32.     SGIS_sharpen_texture affects the definition of this extension.
  33.     SGIX_shadow affects the definition of this extension.
  34.     SGIX_shadow_ambient affects the definition of this extension.
  35.     SGIX_clipmap affects the definition of this extension.
  36.     SGIS_point_line_texgen affects the definition of this extension.
  37.  
  38. Overview
  39.  
  40.     This extension adds support for multiple active textures.  The texture
  41.     capabilities are symmetric for all active textures.  Any texture capability
  42.     extension supported for one texture must be supported for all active
  43.     textures.  Each active texture has its own state vector which includes
  44.     texture image and filtering parameters and texture environment application.
  45.  
  46.     The texture environments are applied in a pipelined fashion whereby the
  47.     output of one texture environment is used as the input fragment color for
  48.     the texture environment for the next active texture.  Changes to texture
  49.     state other than texture coordinates are routed through a selector which
  50.     controls which instance of texture state is affected.
  51.  
  52.           +-----+
  53.      Cf ----->|     |    +-----+        pipelined texture
  54.               | TE0 |--->|     |        environment
  55.     Ct0 ----->|     |    | TE1 |    +-----+
  56.           +-----+    |     |--->|     |
  57.     Ct1 ---------------->|     |    | TE2 |    +-----+
  58.                          +-----+    |     |--->|     |
  59.     Ct2 --------------------------->|     |    | TE3 |
  60.                                     +-----+    |     |--> cf'
  61.     Ct3 -------------------------------------->|     |
  62.                            +-----+
  63.         .
  64.         .
  65.         .
  66.  
  67.     Ct<i> = texture color from texture lookup <i>
  68.     Cf    = fragment color
  69.     TE    = texture environment
  70.     
  71.     Texture coordinate set, texture coordinate evaluator state, texture
  72.     generation function, and texture matrix are replicated independently of
  73.     the texture rasterization state and may differ in number from the
  74.     number of textures which can be active during rasterization.
  75.     Post-transform texture coordinates sets are associated with a texture
  76.     rasterization unit by binding them to a texture environment and they may
  77.     be multicast to several texture rasterization units.
  78.  
  79.     The specification is written using four active textures and four
  80.     sets of texture coordinates though the actual number supported is
  81.     implementation dependent and can be larger or smaller than four.
  82.  
  83. Issues
  84.  
  85.     *  MultiTexCoord is an annoying name
  86.  
  87.     *  alternatives for supplying fine grain texcoord
  88.  
  89.     1. Tex<k>Coord<n><T>[v|f](<T> data);
  90.  
  91.        a. efficient, no error checking required
  92.        d. adds *a lot* of new commands
  93.     
  94.     2. MultiTexCoord<n><T>[v|f](enum target, <T> data);
  95.  
  96.        a. only a small number of commands added
  97.        a. can be fairly efficient (may need hw tweak)
  98.        d. needs range checking for <target>
  99.     
  100.         3. reuse TexCoord command and add SelectTextureCoordSetEXT(enum target)
  101.        to control routing
  102.  
  103.        a. only add one new commands
  104.        d. adds a lot of function call overhead when using multiple
  105.           textures
  106.        d. need to range check <target>
  107.  
  108.     *  seems a little hacky to have SelectTextureEXT control texture matrix
  109.        since that is part of transform state and to have it control evaluator
  110.        state yet SELECTED_TEXTURE itself is part of texture state.
  111.  
  112.     *  SelectTextureEXT probably should not affect client state such as
  113.        the vertex array state.
  114.     
  115.     it doesn't any more
  116.  
  117.     *  mechanism to replicate input texcoords across multiple texture paths
  118.        could be done with a pre-transform multicast or post-transform
  119.        multicast.
  120.  
  121.         done using TEXTURE_ENV_COORD_SET_EXT texture parameter
  122.     which is a post-transform mechanism.
  123.  
  124.        RESOLVED: leave the coord source binding separate from
  125.        the texture object state => needs a new command to set it.
  126.  
  127.     *  need proxy/macro object to handle resource constraints
  128.     save for another extension?
  129.  
  130.     *  still need a way to route textures to lighting block :(
  131.  
  132.     defined in light_texture.spec
  133.  
  134.     *  should there be a post-filter colortable per texture?
  135.  
  136.     *  should the number of textures and the number of texture
  137.        coordinate paths be decoupled?
  138.     RESOLVED: yes
  139.     There are some issues with this.  We choose to break
  140.     texture state into 3 pieces:
  141.         1. client state deal with issuing texture coordinates
  142.            from the application
  143.         2. transform state which includes texgen, texture
  144.            matrix, evaluation maps, and texture coordinate
  145.            retrieval from Gets and Feedback.
  146.         3. rasterization state which includes texture
  147.            images, filter parameters and environment.
  148.     2 & 3 are both server state.  there is an implication
  149.     that 1 and 2 are a little more tightly coupled and
  150.     equal in number but we need to keep the client
  151.     state separate.
  152.     There is some clumsyness with referring to the 2nd
  153.     group of state as transform state.  There is a problem
  154.     that the texgen state is part of the texture state
  155.     used in PushAttrib and PopAttrib so some finessing
  156.     is required.
  157.  
  158.     *  special treatment of name 0?
  159.  
  160.     RESOLVED: no
  161.     
  162.     *  more texture environment functions, SUBTRACT, ...?
  163.     leading candidates are SUBTRACT and REVERSE_SUBTRACT
  164.     could also make a new version of environment which is
  165.     similar to blending.
  166.  
  167.     RESOLVED: new environment, see texture_env.spec
  168.     
  169.     * more general combination of texture results?
  170.  
  171.     RESOLVED: do them in add-on specs
  172.     
  173.     * allow texture environment computation to do something
  174.       even when texture is disabled. This contradicts the current
  175.       specification of texturing (the difference would show
  176.       up in the REPLACE environment), so we redefine this
  177.       behavior in a new environment (see texture_env.spec)
  178.  
  179.     * support for interleaved arrays
  180.       
  181.       add a command which acts as a multiplier on the current
  182.       interleaved array token causing the texture coordinate
  183.       array to have <n> contiguous texture coords of the same
  184.       type and format.
  185.  
  186.     * some clarifications:
  187.  
  188.       SelectTextureCoordSetEXT affects client state only and
  189.       affects the commands TexCoord<n>{T}[v], TexCoordPointer,
  190.       EnableClientState, and DisableClientState.  Display lists
  191.       contain texture coordinates for which the binding is fully
  192.       resolved to one of TEXTURE0_EXT ..  TEXTURE<n>_EXT.
  193.  
  194.       I chose to remove MultiTexCoordPointerEXT as it was difficult
  195.       to also include tokens which would make it possible to call
  196.       Enable/DisableClientState with a token corresponding to the
  197.       appropriate texture coordinate set, so SelectTextureCoordSetEXT
  198.       is required to manipulate the array state.  To maintain symmetry,
  199.       I made all commands use SelectTextureCoordSetEXT and the
  200.       MultiTexCoord<n>{T}[v]EXT commands are added to help with
  201.       performance.  An alternative would be to have both
  202.       MultiTexCoordPointerEXT and add new tokens
  203.       TEXTURE_COORD_ARRAY0_EXT .. TEXTURE_COORD_ARRAY<n>_EXT and
  204.       not give TEXTURE_COORD_ARRAY0_EXT the same value as
  205.       TEXTURE_COORD_ARRAY, so that we can have the relationship
  206.       TEXTURE_COORD_ARRAY<i>_EXT = TEXTURE_COORD_ARRAY0_EXT+i.
  207.       This still might cause some confusion/asymmetry if the <target>
  208.       parameter of MultiTexCoordPointerEXT/MultiTexCoord<n>{T}[v]EXT
  209.       is TEXTURE0_EXT .. TEXTURE<n>_EXT but EnableClientState/
  210.       DisableClientState use TEXTURE_COORD_ARRAY0_EXT ..
  211.       TEXTURE_COORD_ARRAY<n>_EXT
  212.  
  213.     
  214.  
  215. New Procedures and Functions
  216.  
  217.     void MultiTexCoord{1234}{sifd}EXT(enum target, T coords);
  218.     void MultiTexCoord{1234}{sifd}vEXT(enum target, T coords);
  219.  
  220.     void InterleavedTextureCoordSetsEXT(int factor);
  221.  
  222.     void SelectTextureEXT(enum target);
  223.  
  224.     void SelectTextureCoordSetEXT(enum target);
  225.  
  226.     void SelectTextureTransformEXT(enum target);
  227.  
  228. New Tokens
  229.  
  230.     Accepted by the <pname> parameters of GetBooleanv, GetIntegerv,
  231.     GetFloatv, and GetDoublev:
  232.  
  233.     SELECTED_TEXTURE_EXT                0x83C0
  234.     SELECTED_TEXTURE_COORD_SET_EXT      0x83C1
  235.     SELECTED_TEXTURE_TRANSFORM_EXT      0x83C2
  236.     MAX_TEXTURES_EXT                    0x83C3
  237.     MAX_TEXTURE_COORD_SETS_EXT          0x83C4
  238.  
  239.     Accepted by the <pname> parameter of TexEnvi, TexEnvf,
  240.     TexEnviv, TexEnvfv, GetTexEnviv, and GetTexEnvfv:
  241.  
  242.     TEXTURE_ENV_COORD_SET_EXT           0x83C5
  243.  
  244.     Accepted by the <target> parameter of SelectTextureEXT,
  245.     SelectTextureTransformEXT, SelectTextureCoordSetEXT,
  246.     MultiTexCoord<n>{T}[v]EXT, and the <param> of TexParameteri and
  247.     TexParameterf, and the <params> parameter of TexParameteriv, and
  248.     TexParameterfv:
  249.  
  250.     TEXTURE0_EXT                        0x83C6
  251.     TEXTURE1_EXT                        0x83C7
  252.     TEXTURE2_EXT                        0x83C8
  253.     TEXTURE3_EXT                        0x83C9
  254.     <reserve enums for 32>
  255.  
  256. Additions to Chapter 2 of the 1.1 Specification (OpenGL Operation)
  257.  
  258.     Section 2.6 Begin/End Paradigm
  259.  
  260.     <amend paragraph 2 & 3>
  261.  
  262.     Each vertex is specified with two, three, or four coordinates.  In
  263.     addition, a current normal, current texture coordinate set, and current
  264.     color may be used in processing each vertex.  Normals are used by the GL in
  265.     lighting calculations; the current normal is a three-dimensional vector
  266.     that may be set by sending three coordinates that specify it.  Texture
  267.     coordinates determine how a texture image is mapped onto a primitive.
  268.     Multiple sets of texture coordinates may be used to specify how multiple
  269.     texture images are mapped onto a primitive.  The number of texture
  270.     coordinate sets supported is implementation dependent but must be at least
  271.     one.
  272.  
  273.     A color is associated with each vertex as it is specified. This associated
  274.     color is either the current color or a color produced by lighting
  275.     depending on whether or not lighting is enabled. Texture coordinates are
  276.     similarly associated with each vertex.  Multiple sets of texture coordinates
  277.     may be associated with a vertex.  Figure 2.2 summarizes the association of
  278.     auxiliary data with a transformed vertex to produce a processed vertex.
  279.  
  280.     <amend figure 2.2 to include multiple texcoord processing blocks
  281.      (current texcoords, texgen, texture matrix)>
  282.  
  283.     <amend paragraph 6>
  284.     Before a color has been assigned to a vertex, the state required by a vertex
  285.     is the vertex's coordinates, the current normal, and the current texture
  286.     coordinate sets.  Once color has been assigned, however, the current normal
  287.     is no longer needed. Because color assignment is done vertex-by-vertex, a
  288.     processed vertex comprises the vertex's coordinates, its assigned color,
  289.     and its texture coordinate sets.
  290.  
  291.  
  292.  
  293.     Section 2.7 Vertex Specifications <texture coordinates>
  294.  
  295.     <amend paragraph 2>
  296.  
  297.     Current values are used in associating auxiliary data with a vertex
  298.     as described in section 2.6.  A current value may be changed at any time
  299.     by issuing an appropriate command.  The commands
  300.  
  301.     void TexCoord{1234}{sifd}(T coords);
  302.     void TexCoord{1234}{sifd}v(T coords);
  303.  
  304.     specify the current homogeneous texture coordinates, named s,t,r, and q.
  305.     The TexCoord1 family of commands set the s coordinate to the provided
  306.     single argument while setting t and r to 0 and q to 1.  Similarly,
  307.     TexCoord2 sets s and t to the specified values, r to 0, and q to 1;
  308.     TexCoord3 sets s, t, and r, with q set to 1, and TexCoord4 sets all four
  309.     texture coordinates.
  310.  
  311.     Implementations may support more than 1 set of texture
  312.     coordinates.  The MultiTexCoord family of commands takes the
  313.     coordinate set to be modified as the <target> parameter.  The
  314.     <target> parameter is one of TEXTURE0_EXT through
  315.     TEXTURE3_EXT. If a <target> parameter greater than the number of
  316.     supported coordinate sets is specified, the command has no effect.
  317.     The command
  318.  
  319.     void SelectTextureCoordSetEXT(enum target);
  320.  
  321.     is used to change the texture coordinate set modified by the TexCoord*
  322.     family of commands.  <target> is one of TEXTURE0_EXT through TEXTURE3_EXT
  323.     corresponding to the texture coordinate set to be modified by the TexCoord
  324.     commands.  The current coordinate set selection is part of client state rather
  325.     than server state.
  326.  
  327.  
  328.     Section 2.8 Vertex Arrays
  329.  
  330.     <amend paragraph 1>
  331.  
  332.     The vertex specification commands in section 2.7 accept data in almost any
  333.     format, but their use requires many command executions to specify even
  334.     simple geometry.  Vertex data may also be placed in arrays that are stored
  335.     in the client's address space. Blocks of data in these arrays may be used
  336.     to specify multiple geometric primitives through the execution of a single
  337.     GL command.  The client may specify 6 or more arrays at once: one each to
  338.     store vertex coordinates, edge flags, colors, color indices, normals and
  339.     one or more texture coordinate sets. The commands
  340.  
  341.     void EdgeFlagPointer(sizei stride, void *pointer);
  342.     void VertexPointer(int size, enum type, sizei stride, void *pointer);
  343.     void ColorPointer(int size, enum type, sizei stride, void *pointer);
  344.     void IndexPointer(enum type, sizei stride, void *pointer);
  345.     void NormalPointer(enum type, sizei stride, void *pointer);
  346.     void TexCoordPointer(int size, enum type, sizei stride, void *pointer);
  347.  
  348.     ...
  349.  
  350.     <insert this paragraph> between paragraph 2 & 3>
  351.  
  352.     In implementations which support more than one set of texture coordinates,
  353.     the command SelectTextureCoordSetEXT is used to select the vertex array
  354.     parameters to be modified by the TexCoordPointer command and the array
  355.     affected by client state enable and disable commands with the
  356.     TEXTURE_COORD_ARRAY parameter.
  357.  
  358.     <modify the section on interleaved arrays as follows>
  359.  
  360.     The commands
  361.  
  362.     void InterleavedArrays(enum format, sizei stride,
  363.         void *pointer) ;
  364.     
  365.         void InterleavedTextureCoordSetsEXT(int factor) ;
  366.     
  367.     efficiently initializes the six arrays and their enables to one of 14
  368.     configurations. <format> must be one 14 symbolic constants: V2F, V3F,
  369.     C4UB_V2F, C4UB_V3F, C3F_V3F, N3F_V3F, C4F_N3F_V3F, T2F_V3F, T4F_V4F,
  370.     T2F_C4UB_V3F, T2F_C3F_V3F, T2F_N3F_V3F, T2F_C4F_N3F_V3F, T4F_C4F_N3F_V4F.
  371.     <factor> is an integer between 1 and SELECTED_TEXTURE_COORD_SET_EXT
  372.     and specifies how many texture coordinate sets are enabled as part
  373.     of the InterleavedArrays command.
  374.  
  375.     The effect of
  376.  
  377.         InterleavedArrays(format, stride, pointer);
  378.             InterleavedTextureCoordSetsEXT(factor);
  379.  
  380.     is the same as the effect of the command sequence
  381.  
  382.        <copy command sequence from 1.1 spec, but change the part dealing
  383.         with texture coords to>
  384.  
  385.             GetIntegerv(SELECTED_TEXTURE_COORD_SET_EXT, &x);
  386.         if (<et>) {
  387.         for(i = 0; i < factor; i++) {
  388.                     SelectTextureCoordSetEXT(TEXTURE0_EXT+i);
  389.             EnableClientState(TEXTURE_COORD_ARRAY);
  390.             TexCoordPointer(st, FLOAT, str, <pointer>+i*pc);
  391.         }
  392.                 for(i = factor; i < MAX_TEXTURE_COORD_SETS_EXT; i++) {
  393.                     SelectTextureCoordSetEXT(TEXTURE0_EXT+i);
  394.             DisableClientState(TEXTURE_COORD_ARRAY);
  395.         }
  396.         } else {
  397.                 for(i = 0; i < MAX_TEXTURE_COORD_SETS_EXT; i++) {
  398.                     SelectTextureCoordSetEXT(TEXTURE0_EXT+i);
  399.             DisableClientState(TEXTURE_COORD_ARRAY);
  400.         }
  401.         }
  402.             SelectTextureCoordSetEXT(x);
  403.         pc *= factor;
  404.     
  405.  
  406.     If the number of supported is texture coordinate sets,
  407.     MAX_TEXTURE_COORD_SETS_EXT, is <k>, then the client state require to
  408.     implement vertex arrays consists of five plus <k> boolean values, five
  409.     plus <k> integer stride values, four plus <k> constants representing array
  410.     types, and three plus <k> integers representing values per element.  In the
  411.     initial state, the boolean values are each disabled, the memory pointers
  412.     are each null, the strides are each zero, the array types are each FLOAT,
  413.     and the integers representing values per element are each four.
  414.  
  415.  
  416.     Section 2.10.2 Matrices
  417.     
  418.     <amend paragraph 8 texture matrix>
  419.  
  420.     There is another 4x4 matrix that is applied to texture coordinates.
  421.     This matrix is applied as
  422.  
  423.         | m1 m5 m9  m13 | |s|
  424.         | m2 m6 m10 m14 | |t| ,
  425.         | m3 m7 m11 m15 | |r|
  426.         | m4 m8 m12 m16 | |q|
  427.  
  428.     where the left matrix is the current texture matrix.  The Matrix is applied
  429.     to the coordinates resulting from texture coordinate generation which
  430.     (which may simply be the current texture coordinates), and the resulting
  431.     transformed coordinates become the texture coordinates associated with a
  432.     vertex.  Setting the matrix mode to TEXTURE causes the already described
  433.     matrix operations to apply to the texture matrix stack.
  434.  
  435.     For implementations which support more than one set of texture coordinates,
  436.     there is a corresponding texture matrix stack for each coordinate set. Each
  437.     stack has the same depth. The texture matrix stack which is affected by the
  438.     matrix operations is set using the SelectTextureTransformEXT command.
  439.  
  440.     There is a stack of matrices for each of the matrix modes.  For MODELVIEW
  441.     mode, the stack depth is at least 32 (that is, there is a stack of at least
  442.     32 model-view matrices). For other modes, the depth is at least 2.  Texture
  443.     matrix stacks for all texture coordinate sets have the same depth.
  444.  
  445.     void PushMatrix( void );
  446.  
  447.     pushes the stack down by one, duplicating the current matrix in both the
  448.     top of the stack and the entry below it.
  449.  
  450.     void PopMatrix( void );
  451.     
  452.     pops the top entry off of the stack, replacing the current matrix with the
  453.     matrix that was the second entry in the stack.  The pushing or popping
  454.     takes place on the stack corresponding to the current matrix mode.  Popping
  455.     a matrix off a stack with only one entry generates the error STACK_UNDERFLOW;
  456.     pushing a matrix onto a full stack generates STACK_OVERFLOW.
  457.  
  458.     When the current matrix mode is TEXTURE, the texture matrix stack corresponding
  459.     to the currently selected textured is pushed or popped.
  460.  
  461.     The state required to implement transformations consists of a three-value
  462.     integer indicating the current matrix mode, a stack of at least two 4x4
  463.     matrices for PROJECTION and one stack of at least two 4x4 matrices for
  464.     each set of texture coordinates, TEXTURE, as well as associated stack pointers,
  465.     and a stack of at least 32 4x4 matrices with an associated stack pointer for
  466.     MODELVIEW.  Initially, there is only one matrix on each stack and all
  467.     matrices are set to the identity.  The initial matrix mode is MODELVIEW.
  468.  
  469.     Section 2.10.4 Generating texture coordinates
  470.  
  471.     <amend paragraph 4>
  472.  
  473.     The state required for texture coordinate generation for each set of
  474.     texture coordinates supported by the implementation comprises a
  475.     three-valued integer for each coordinate indicating coordinate generation
  476.     mode, and a bit for each coordinate to indicate whether texture coordinate
  477.     generation is enabled or disabled.  In addition, four coefficients are
  478.     required for the four coordinates for each of EYE_LINEAR and
  479.     OBJECT_LINEAR.  The initial state has the texture generation function
  480.     disabled for all texture coordinates.  The initial values of p_i for s
  481.     except p_1 which is one; for t all the p_i are zero except p_2, which is
  482.     1.  The values of p_i for r and q are all zero.  These values of p_i apply
  483.     for both the EYE_LINEAR and OBJECT_LINEAR versions.  Initially all texture
  484.     generation modes are EYE_LINEAR.
  485.  
  486.     Section 2.12  Current Raster Position
  487.  
  488.     <amend paragraph 2>
  489.  
  490.     The current raster position consists of three window coordinates x_w,
  491.     y_w, and z_w, a clip coordinate w_c value, and eye coordinate distance,
  492.     a valid bit, and associated data consisting op a color and texture
  493.     coordinate sets.  It is set using one of the RasterPos commands:
  494.     ...
  495.  
  496.     <amend paragraph 5>
  497.  
  498.     The current raster position requires five single-precision floating-point
  499.     values for its x_w, y_w, and z_w window coordinates, its w_c clip
  500.     coordinate, and its eye coordinate distance, a single valid bit, a color
  501.     (RGBA and color index), and texture coordinates for each set of texture
  502.     coordinates supported by the implementation.  In the initial state, the
  503.     coordinates and texture coordinates and both (0,0,0,1), the eye coordinate
  504.     distance is 0, the valid bit is set, the associated RGBA color is (1,1,1,1)
  505.     and the associated color index is 1. In RGBA mode, the associated color
  506.     index always has its initial value; in color index mode, the RGBA color
  507.     always maintains its initial value.
  508.  
  509.  
  510. Additions to Chapter 3 of the 1.1 Specification (Rasterization)
  511.  
  512.     Section 3.8 Texturing
  513.  
  514.     <amend paragraphs 1 & 2>
  515.  
  516.     Texturing maps a portion of one or more specified images onto each
  517.     primitive for which texturing is enabled.  This mapping is accomplished by
  518.     using the color of an image at the location indicated by a fragment's
  519.     (s,t,r) coordinates to modify the fragment's RGBA color (r is currently
  520.     ignored).  An implementation may support texturing using more than one
  521.     image at a time.  In this case the fragment carries multiple sets of
  522.     texture coordinates (s,t,r) which are used to index separate images to
  523.     produce color values which are collectively used to modify the fragment's
  524.     RGBA color.  Texturing is specified only for RGBA mode; its use in color
  525.     index mode is undefined.  The following subsections (up to and including
  526.     Section 3.8.5) specify the GL operation with a single texture and Section
  527.     3.8.6 specifies the details of how multiple textures interact.
  528.  
  529.     The GL provides a means to specify the details of how texturing of a
  530.     primitive is effected. These details include specifications of the image to
  531.     be texture mapped, the means by which the image is filtered when applied to
  532.     the primitive, and the function that determines what RGBA value is produced
  533.     given a fragment color and an image value.
  534.  
  535.  
  536.     Section 3.8.4 Texture Objects
  537.  
  538.     <add this paragraph to the end of the section>
  539.  
  540.     The texture object name space is shared amongst all textures in multiple
  541.     texture implementations.   A texture object may be bound to more than one
  542.     texture target simultaneously, though they must all be of the same type
  543.     (e.g., TEXTURE_1D, TEXTURE_2D).  After a texture object is bound, any GL
  544.     operations on that target also affect any other target to which the same
  545.     texture object is bound.
  546.  
  547.  
  548.     Section 3.8.5 Texture Environments and Texture Functions
  549.  
  550.     <amend the second half of paragraph 1>
  551.     The possible environment parameters are TEXTURE_ENV_MODE,
  552.     TEXTURE_ENV_COLOR, and TEXTURE_ENV_COORD_SET_EXT.  TEXTURE_ENV_MODE may be
  553.     set to one of REPLACE, MODULATE, DECAL, or BLEND; TEXTURE_ENV_COLOR is set
  554.     to an RGBA color by providing four single-precision floating-point values
  555.     in the range [0,1](values outside this range are clamped to it).  If
  556.     integers are provided for TEXTURE_ENV_COLOR, then they are converted to
  557.     floating-point as specified in Table 2.6 for signed integers.
  558.     TEXTURE_ENV_COORD_SET_EXT may be set to one of TEXTURE0_EXT ..
  559.     TEXTURE<n>_EXT where <n> is one less than the number of supported
  560.     texture coordinate sets.  If a floating-point value is provided, then it
  561.     is rounded to the nearest integer.
  562.  
  563.     <insert before paragraph 3>
  564.  
  565.     The value of TEXTURE_ENV_COORD_SET_EXT specifies which set of fragment
  566.     texture coordinates are used to determine the texture value used in
  567.     the texture function.  The same set of texture coordinates may
  568.     be simultaneously used by multiple textures.
  569.  
  570.     <replace paragraph 3>
  571.  
  572.     The state required for the current texture environment consists of the
  573.     four-valued integer indicating the texture function, four floating-
  574.     point TEXTURE_ENV_COLOR values, and one MAX_TEXTURE_COORD_SETS_EXT-valued
  575.     integer indicating the texture coordinate set binding. In the initial
  576.     state, the texture function is given by MODULATE, TEXTURE_ENV_COLOR is
  577.     (0,0,0,0), and texture coordinate set is TEXTURE0_EXT.
  578.  
  579.  
  580.     Section 3.8.6 Texture Application <replace with this>
  581.  
  582.     Texturing is enabled or disabled using the generic Enable and Disable
  583.     commands, respectively, with the symbolic constant TEXTURE_1D or TEXTURE_2D
  584.     to enable the one-dimensional or two-dimensional texture, respectively.  If
  585.     both the one- and two-dimensional textures are enabled, the two-dimensional
  586.     texture is used.  If all texturing is disabled, a rasterized fragment is
  587.     passed unaltered to the next stage of the GL (although its texture
  588.     coordinates may be discarded).  Otherwise, a texture value is found
  589.     according to the parameter values of the currently bound texture image of
  590.     the appropriate dimensionality using the rules given in sections 3.8.1 and
  591.     3.8.2.  This texture value is used along with the incoming fragment in
  592.     computing the texture function indicated by the currently bound texture
  593.     environment.  The result of this function replaces the incoming fragment's
  594.     R, G, B, and A values.  These are the color values passed to subsequent
  595.     operations.  Other data associated with the incoming fragment remain
  596.     unchanged, except that the texture coordinates may be discarded.
  597.  
  598.     When multiple textures are supported, additional textures are each paired
  599.     with an environment function.  The second texture function is computed
  600.     using the texture value from the second texture, the fragment resulting
  601.     from the first texture function computation and the environment function
  602.     currently bound to the second texture.  If there is a third texture, the
  603.     fragment resulting from the second texture function is combined with the
  604.     third texture value using the environment function bound to the third
  605.     texture and so on.  Texturing is enabled and disabled individually for each
  606.     texture.  If texturing is disabled for one of the textures, then the
  607.     fragment result from the previous stage is passed unaltered to the next
  608.     stage.
  609.  
  610.  
  611. Additions to Chapter 4 of the 1.1 Specification (Per-Fragment Operations
  612. and the Framebuffer)
  613.  
  614.  
  615. Additions to Chapter 5 of the 1.1 Specification (Special Functions)
  616.  
  617.     Section 5.1 Evaluators
  618.  
  619.     <amend second part of paragraph 2 to indicate that the evaluator
  620.     map modified is affected by SELECTED_TEXTURE_TRANSFORM_EXT when the
  621.     the type parameter is one of the texture coordinates.>
  622.  
  623.     <amend paragraph 7>
  624.  
  625.     The evaluation of a defined map is enabled or disabled with Enable and
  626.     Disable using the constant corresponding to the map as described
  627.     above.  In implementations which support multiple texture coordinates the
  628.     affected texture evaluator map is further qualified by the value of
  629.     SELECTED_TEXTURE_TRANSFORM_EXT.  The error INVALID_VALUE results if
  630.     either ustride or vstride is less than k, or if u1 is equal to u2, or
  631.     if v1 is equal to v2.
  632.  
  633.  
  634.     Section 5.3 Feedback
  635.  
  636.     <amend bottom of paragraph 2>
  637.  
  638.     The texture coordinates and colors returned are these resulting from the
  639.     clipping operations described in (section 2.13.8).  Only one set of texture
  640.     coordinates is returned even for implementations which support multiple
  641.     texture coordinates.  The texture coordinate set returned is the the one
  642.     corresponding to the value of SELECTED_TEXTURE_TRANSFORM_EXT.
  643.  
  644.  
  645. Additions to Chapter 6 of the 1.1 Specification (State and State Requests)
  646.  
  647.     <add this paragraph after paragraph 14 regarding multi-valued state variables>
  648.  
  649.     When multiple textures are supported, most texture state variables are
  650.     further qualified by the value of SELECTED_TEXTURE_TRANSFORM_EXT or
  651.     SELECTED_TEXTURE_EXT to determine which server texture state vector is
  652.     queried.  Client texture state variables such as texture coordinate
  653.     array pointers are qualified with SELECTED_TEXTURE_COORD_SET_EXT.
  654.     Tables 6.5 through 6.22 indicate those state variables which are
  655.     qualified by SELECTED_TEXTURE_TRANSFORM_EXT, SELECTED_TEXTURE_EXT or
  656.     SELECTED_TEXTURE_COORD_SET_EXT during state queries.
  657.  
  658.     <add this paragraph after paragraph 16 regarding the TEXTURE_BIT>
  659.  
  660.     When multiple textures are supported, operations on groups containing
  661.     replicated texture state push or pop all versions of texture state
  662.     within that group.  When server state for a group is pushed all state
  663.     in the group corresponding to TEXTURE0_EXT is pushed first, followed by
  664.     state corresponding to TEXTURE1_EXT, and so on up to and including the
  665.     state corresponding to TEXTURE<n>_EXT where <n> is the value of
  666.     max{MAX_TEXTURES_EXT, MAX_TEXTURE_COORD_SETS_EXT}.  If state does
  667.     not exist for an attribute (this can occur when MAX_TEXTURES_EXT is
  668.     not equal to MAX_TEXTURE_COORD_SETS_EXT) then it is ignored.
  669.     When server state for a group is popped the replicated texture state is
  670.     restored in the opposite order that it was pushed, starting with state
  671.     corresponding to TEXTURE<n>_EXT and ending with TEXTURE0_EXT.
  672.     Identical rules are observed for client texture state push and pop
  673.     operations.
  674.  
  675.     <rename vertex_array attribute group to vertex>
  676.  
  677.  
  678. Additions to the GLX Specification
  679.  
  680.     None
  681.     
  682. GLX Protocol
  683.  
  684.     TBD
  685.  
  686. Dependencies on EXT_texture3D
  687.  
  688.     If EXT_texture3D is not supported than the functionality and state
  689.     associated with EXT_texture3D does not exist and is therefore not
  690.     extended.
  691.  
  692. Dependencies on SGIS_texture4D
  693.  
  694.     If SGIS_texture4D is not supported than the functionality and state
  695.     associated with SGIS_texture4D does not exist and is therefore not
  696.     extended.
  697.  
  698. Dependencies on SGIS_texture_border_clamp
  699.  
  700.     If SGIS_texture_border_clamp is not supported than the functionality and
  701.     state associated with SGIS_texture_border_clamp does not exist and is
  702.     therefore not extended.
  703.  
  704. Dependencies on SGI_texture_color_table
  705.  
  706.     If SGI_texture_color_table is not supported than the functionality and
  707.     state associated with SGI_texture_color_table does not exist and is
  708.     therefore not extended.
  709.  
  710. Dependencies on SGIS_texture_edge_clamp
  711.  
  712.     If SGIS_texture_edge_clamp is not supported than the functionality and
  713.     state associated with SGIS_texture_edge_clamp does not exist and is
  714.     therefore not extended.
  715.  
  716. Dependencies on SGIX_texture_add_env
  717.  
  718.     If SGIX_texture_add_env is not supported than the functionality and
  719.     state associated with SGIX_texture_add_env does not exist and is
  720.     therefore not extended.
  721.  
  722. Dependencies on SGIS_texture_filter4
  723.  
  724.     If SGIS_texture_filter4 is not supported than the functionality and
  725.     state associated with SGIS_texture_filter4 does not exist and is
  726.     therefore not extended.
  727.  
  728. Dependencies on SGIS_texture_lod
  729.  
  730.     If SGIS_texture_lod is not supported than the functionality and state
  731.     associated with SGIS_texture_lod does not exist and is therefore not
  732.     extended.
  733.  
  734. Dependencies on SGIX_texture_lod_bias
  735.  
  736.     If SGIX_texture_lod_bias is not supported than the functionality and
  737.     state associated with SGIX_texture_lod_bias does not exist and is
  738.     therefore not extended.
  739.  
  740. Dependencies on SGIX_texture_scale_bias
  741.  
  742.     If SGIX_texture_scale_bias is not supported than the functionality and
  743.     state associated with SGIX_texture_scale_bias does not exist and is
  744.     therefore not extended.
  745.  
  746. Dependencies on SGIS_texture_select
  747.  
  748.     If SGIS_texture_select is not supported than the functionality and state
  749.     associated with SGIS_texture_select does not exist and is therefore not
  750.     extended.
  751.  
  752. Dependencies on SGIS_detail_texture
  753.  
  754.     If SGIS_detail_texture is not supported than the functionality and state
  755.     associated with SGIS_detail_texture does not exist and is therefore not
  756.     extended.
  757.  
  758. Dependencies on SGIS_sharpen_texture
  759.  
  760.     If SGIS_sharpen_texture is not supported than the functionality and
  761.     state associated with SGIS_sharpen_texture does not exist and is
  762.     therefore not extended.
  763.  
  764. Dependencies on SGIX_shadow
  765.  
  766.     If SGIX_shadow is not supported than the functionality and state
  767.     associated with SGIX_shadow does not exist and is therefore not
  768.     extended.
  769.  
  770. Dependencies on SGIX_shadow_ambient
  771.  
  772.     If SGIX_shadow_ambient is not supported than the functionality and state
  773.     associated with SGIX_shadow_ambient does not exist and is therefore not
  774.     extended.
  775.  
  776. Dependencies on SGIX_clipmap
  777.  
  778.     If SGIX_clipmap is not supported than the functionality and state
  779.     associated with SGIX_clipmap does not exist and is therefore not
  780.     extended.
  781.  
  782. Dependencies on SGIS_point_line_texgen
  783.  
  784.     If SGIS_point_line_texgen is not supported than the functionality and
  785.     state associated with SGIS_point_line_texgen does not exist and is
  786.     therefore not extended.
  787.  
  788.  
  789. Errors
  790.  
  791.     INVALID_ENUM is generated if SelectTextureEXT, SelectTextureTransformEXT,
  792.     SelectTextureCoordSetEXT, MultiTexCoord<n>{T}[v], or MultiTexCoordPointer
  793.     parameter <target> is not TEXTURE0_EXT ..  TEXTURE3_EXT.
  794.  
  795.     INVALID_OPERATION is generated if SelectTextureCoordSetEXT or
  796.     SelectTextureTransformEXT parameter <target> is one of TEXTURE0_EXT
  797.     .. TEXTURE3_EXT and <target> is greater or equal than the number of
  798.     available textures coordinate sets.
  799.  
  800.     INVALID_VALUE is generated if InterleavedTextureCoordSetsEXT parameter
  801.     <factor> is not between 1 and MAX_TEXTURE_COORD_SETS_EXT.
  802.  
  803.     INVALID_OPERATION is generated if SelectTextureEXT parameter <target> is
  804.     one of TEXTURE0_EXT .. TEXTURE3_EXT and <target> is greater or equal than
  805.     the number of available textures.
  806.  
  807.     INVALID_ENUM is generated if TexEnv{T}[v] parameter <pname> is
  808.     TEXTURE_ENV_COORD_SET_EXT and the <param> parameter is not one of
  809.     TEXTURE0_EXT .. TEXTURE3_EXT.
  810.  
  811.     INVALID_OPERATION is generated if TexEnv{T}[v] parameter <pname>
  812.     is TEXTURE_ENV_COORD_SET_EXT and the <param> parameter is greater or equal
  813.     than the number of available textures coordinate sets.
  814.  
  815.     INVALID_OPERATION is generated if SelectTextureEXT or
  816.     SelectTextureTransformEXT is executed between execution of Begin and the
  817.     corresponding execution of End.
  818.  
  819.     INVALID_OPERATION is generated if SelectTextureCoordSetEXT or
  820.     MultiTexCoordPointerEXT  is executed between execution of Begin and the
  821.     corresponding execution of End, but some implementations may not generate
  822.     the error.  In such cases the result of executing these commands is
  823.     undefined.
  824.  
  825. New State
  826.  
  827.     Get Value                Get Command        Type        Initial Value        Attribute
  828.     ---------                -----------        ----        -------------        ---------
  829.     SELECTED_TEXTURE_EXT                GetIntegerv             Z4              TEXTURE0_EXT           texture
  830.     SELECTED_TEXTURE_TRANSFORM_EXT      GetIntegerv             Z4              TEXTURE0_EXT           texture
  831.     SELECTED_TEXTURE_COORD_SET_EXT      GetIntegerv             Z4              TEXTURE0_EXT           vertex
  832.     TEXTURE_COORD_SET_INTERLEAVE_FACTOR_EXT     GetIntegerv     Z4              1                       vertex
  833.  
  834. Replicated State
  835.  
  836.     Get Value                Get Command        Type        Initial Value        Attribute
  837.     ---------                -----------        ----        -------------        ---------
  838.   x CURRENT_TEXTURE_COORDS        GetFloatv        1* x T        (0,0,0,1)        current
  839.   x CURRENT_RASTER_TEXTURE_COORDS    GetFloatv        1* x T        (0,0,0,1)        current
  840.  
  841.   c TEXTURE_COORD_ARRAY            IsEnabled        1* x B        False            vertex-array
  842.   c TEXTURE_COORD_ARRAY_SIZE        GetIntegerv        1* x Z+        0            vertex-array
  843.   c TEXTURE_COORD_ARRAY_TYPE        GetIntegerv        1* x Z4        FLOAT            vertex-array
  844.   c TEXTURE_COORD_ARRAY_STRIDE        GetIntegerv        1* x Z+        0            vertex-array
  845.   c TEXTURE_COORD_ARRAY_POINTER        GetPointerv        1* x Y        0            vertex-array
  846.  
  847.   x TEXTURE_MATRIX            GetFloatv        1* x 2* x M4    Identity        -
  848.   x TEXTURE_STACK_DEPTH            GetIntegerv        1* x Z+        1            -
  849.  
  850.     TEXTURE_1D                IsEnabled        1* x B        False            texture/enable
  851.     TEXTURE_2D                IsEnabled        1* x B        False            texture/enable
  852.     TEXTURE_3D_EXT            IsEnabled        1* x B        False            texture/enable
  853.     TEXTURE_4D_SGIS            IsEnabled        1* x B        False            texture/enable
  854.     TEXTURE_BINDING_1D            GetIntegerv        1* x Z+        0            texture
  855.     TEXTURE_BINDING_2D            GetIntegerv        1* x Z+        0            texture
  856.     TEXTURE_BINDING_3D_EXT        GetIntegerv        1* x Z+        0            texture
  857.     TEXTURE_BINDING_4D_SGIS        GetIntegerv        1* x Z+        0            texture
  858.     TEXTURE                GetTexImage        1* x n x I    see sec 3.8        -
  859.     TEXTURE_WIDTH            GetTexLevelParameter    1* x n x Z+    0            -
  860.     TEXTURE_HEIGHT            GetTexLevelParameter    1* x n x Z+    0            -
  861.    +TEXTURE_DEPTH_EXT            GetTexLevelParameter    1* x n x Z+    0            -
  862.     TEXTURE_BORDER            GetTexLevelParameter    1* x n x Z+    0            -
  863.     TEXTURE_INTERNAL_FORMAT        GetTexLevelParameter    1* x n x Z+    0            -
  864.     (TEXTURE_COMPONENTS)
  865.     TEXTURE_RED_SIZE            GetTexLevelParameter    1* x n x Z+    0            -
  866.     TEXTURE_GREEN_SIZE            GetTexLevelParameter    1* x n x Z+    0            -
  867.     TEXTURE_BLUE_SIZE            GetTexLevelParameter    1* x n x Z+    0            -
  868.     TEXTURE_ALPHA_SIZE            GetTexLevelParameter    1* x n x Z+    0            -
  869.     TEXTURE_LUMINANCE_SIZE        GetTexLevelParameter    1* x n x Z+    0            -
  870.     TEXTURE_INTENISTY_SIZE        GetTexLevelParameter    1* x n x Z+    0            -
  871.     TEXTURE_BORDER_COLOR        GetTexParameter        1* x 2+ x C    (0,0,0,0)        texture
  872.     TEXTURE_MIN_FILTER            GetTexParameter        1* x 2+ x Z6    see sec 3.8        texture
  873.     TEXTURE_MAG_FILTER            GetTexParameter        1* x 2+ x Z2    see sec 3.8        texture
  874.     TEXTURE_WRAP_S            GetTexParameter        1* x 2+ x Z2    REPEAT            texture
  875.     TEXTURE_WRAP_T            GetTexParameter        1* x 2+ x Z2    REPEAT            texture
  876.    +TEXTURE_WRAP_R_EXT            GetTexParameter        1* x 2+ x Z2    REPEAT            texture
  877.    +TEXTURE_WRAP_Q_SGIS            GetTexParameter        1* x 2+ x Z2    REPEAT            texture
  878.     TEXTURE_PRIORITY            GetTexParameterfv    1* x 2+ x R[0,1]    1        texture
  879.     TEXTURE_RESIDENT            GetTexParameterfv    1* x 2+ x B    False            texture
  880.  
  881.    +TEXTURE_MIN_LOD_SGIS        GetTexParameterfv       1* x n x R    -1000            texture
  882.    +TEXTURE_MAX_LOD_SGIS        GetTexParameterfv       1* x n x R     1000            texture
  883.    +TEXTURE_BASE_LEVEL_SGIS        GetTexParameteriv       1* x n x R        0            texture
  884.    +TEXTURE_MAX_LEVEL_SGIS        GetTexParameteriv       1* x n x R     1000            texture
  885.  
  886.    +TEXTURE_LOD_BIAS_S_SGIX        GetTexParameterfv       1* x n x R         0               texture
  887.    +TEXTURE_LOD_BIAS_T_SGIX        GetTexParameterfv       1* x n x R         0               texture
  888.    +TEXTURE_LOD_BIAS_R_SGIX        GetTexParameterfv       1* x n x R         0               texture
  889.  
  890.    +TEXTURE_FILTER4_FUNC_SGIS        GetTexFilterFuncSGIS    1* x 2 x Size x R    see text    texture
  891.  
  892.    +DETAIL_TEXTURE_2D_BINDING_SGIS    GetIntegerv        1* x Z+        0            texture
  893.    +DETAIL_TEXTURE_LEVEL_SGIS        GetTexParameteriv    1* x n x Z-    -4            texture
  894.    +DETAIL_TEXTURE_MODE_SGIS        GetTexParameteriv    1* x n x Z2    ADD            texture
  895.    +DETAIL_TEXTURE_FUNC_POINTS_SGIS    GetTexParameteriv    1* x n x Z+    2            texture
  896.    +<DETAIL_TEXTURE_FUNC>        GetDetailTexFuncSGIS    1* x n x m x R    {0, 0}, {-4, 1}        texture
  897.  
  898.    +SHARPEN_TEXTURE_FUNC_POINTS_SGIS    GetTexParameteriv    1* x n x Z+    2            texture
  899.    +<SHARPEN_TEXTURE_FUNC>        GetSharpenTexFuncSGIS    1* x n x m x R    {0, 0}, {-4, 1}        texture
  900.  
  901.    +TEXTURE_COMPARE_SGIX        GetTexParameter[if]v    1* x B        False            texture
  902.    +TEXTURE_COMPARE_OPERATOR_SGIX    GetTexParameter[if]v    1* x Z_2    TEXTURE_LEQUAL_R_SGIX    texture
  903.  
  904.    +SHADOW_AMBIENT_SGIX            GetTexParameter[if]v    1* x R[0,1]    0.0            texture
  905.  
  906.    +TEXTURE_CLIPMAP_FRAME_SGIX       GetTexParameterf    1* x Z+        0            texture
  907.    +TEXTURE_CLIPMAP_CENTER_SGIX         GetTexParameterfv    1* x 2 x Z+    0,0            texture
  908.    +TEXTURE_CLIPMAP_OFFSET_SGIX         GetTexParameterfv    1* x 2 x Z+    0,0            texture
  909.    +TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX    GetTexParameterfv    1* x 3 x Z+    0,0,0            texture
  910.  
  911.    +DUAL_TEXTURE_SELECT_SGIS        GetTexParameter        1* x n x 3 x Z2    0            texture
  912.    +QUAD_TEXTURE_SELECT_SGIS        GetTexParameter        1* x n x 3 x Z4    0            texture
  913.  
  914.    +POST_TEXTURE_FILTER_BIAS_SGIX    GetTexParameterfv    1* x n x 4 x R    (0,0,0,0)        texture
  915.    +POST_TEXTURE_FILTER_SCALE_SGIX    GetTexParameterfv    1* x n x 4 x R    (1,1,1,1)        texture
  916.  
  917.     TEXTURE_COLOR_TABLE_SGI        IsEnabled            B        False        texture/enable
  918.    +COLOR_TABLE                GetColorTableSGI        4 x I        empty        -
  919.    +COLOR_TABLE_FORMAT_SGI        GetColorTableParameterivSGI    2 x 4 x Z38    RGBA        -
  920.    +COLOR_TABLE_WIDTH_SGI        GetColorTableParameterivSGI    2 x 4 x Z+    0        -
  921.    +COLOR_TABLE_RED_SIZE_SGI        GetColorTableParameterivSGI    2 x 4 x Z+    0        -
  922.    +COLOR_TABLE_GREEN_SIZE_SGI        GetColorTableParameterivSGI    2 x 4 x Z+    0        -
  923.    +COLOR_TABLE_BLUE_SIZE_SGI        GetColorTableParameterivSGI    2 x 4 x Z+    0        -
  924.    +COLOR_TABLE_ALPHA_SIZE_SGI        GetColorTableParameterivSGI    2 x 4 x Z+    0        -
  925.    +COLOR_TABLE_LUMINANCE_SIZE_SGI    GetColorTableParameterivSGI    2 x 4 x Z+    0        -
  926.    +COLOR_TABLE_INTENSITY_SIZE_SGI    GetColorTableParameterivSGI    2 x 4 x Z+    0        -
  927.    +COLOR_TABLE_SCALE_SGI        GetColorTableParameterfvSGI    4 x R4        (1,1,1,1)    pixel
  928.    +COLOR_TABLE_BIAS_SGI        GetColorTableParameterfvSGI    4 x R4        (0,0,0,0)    pixel
  929.  
  930.     TEXTURE_ENV_MODE            GetTexEnviv        1* x Z4        MODULATE        texture
  931.     TEXTURE_ENV_COLOR            GetTexEnviv        1* x C        (0,0,0,0)        texture
  932.     TEXTURE_ENV_COORD_SET_EXT           GetTexEnviv             1* x Z4         see sec 3.8             texture
  933.   x TEXTURE_GEN_x            IsEnabled        1* x 4 x B    False            texture/enable
  934.   x EYE_PLANE                GetTexGenfv        1* x 4 x R4    see sec 2.10.4        texture
  935.   x OBJECT_PLANE            GetTexGenfv        1* x 4 x R4    see sec 2.10.4        texture
  936.   x TEXTURE_GEN_MODE            GetTexGeniv        1* x 4 x Z3    EYE_LINEAR        texture
  937.  
  938.    +TEXTURE_ENV_BIAS_SGIX        GetFloatv        1* x C        (0,0,0,0)        texture
  939.  
  940.   x+EYE_POINT_SGIS            GetTexGeniv        1* x 4 x R    (0,0,0,1)        texture
  941.   x+OBJECT_POINT_SGIS            GetTexGeniv        1* x 4 x R    (0,0,0,1)        texture
  942.   x+EYE_LINE_SGIS            GetTexGeniv        1* x 7 x R    (0,0,0,1,0,0,1)        texture
  943.   x+OBJECT_LINE_SGIS            GetTexGeniv        1* x 7 x R    (0,0,0,1,0,0,1)        texture
  944.  
  945.   x ORDER                GetMapiv        (k+9) x Z8*    1            -
  946.   x ORDER                GetMapiv        (k+9) x 2 x Z8*    1,1            -
  947.   x COEFF                GetMapfv        (k+9) x 8* x Rn    see sec 5.1        -
  948.   x COEFF                GetMapfv        (k+9) x 8* x 8* x Rn    see sec 5.1        -
  949.   x DOMAIN                GetMapfv        (k+9) x 2 x R    see sec 5.1        -
  950.   x DOMAIN                GetMapfv        (k+9) x 4 x R    see sec 5.1        -
  951.   x MAP1_x                IsEnabled        (k+9) x B    False            -
  952.   x MAP2_x                IsEnabled        (k+9) x B    False            -
  953.  
  954. + = state defined in another extension.
  955. x = state qualified by SELECTED_TEXTURE_TRANSFORM_EXT
  956. c = state qualified by SELECTED_TEXTURE_COORD_SET_EXT
  957.  
  958. New Implementation Dependent State
  959.  
  960.     Get Value                Get Command        Type        Minimum Value
  961.     ---------                -----------        ----        -------------
  962.     MAX_TEXTURES_EXT                    GetIntegerv             Z+              1
  963.     MAX_TEXTURE_COORD_SETS_EXT          GetIntegerv             Z+              1
  964.